﻿using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Text;
using System.Data.SqlClient;
using System.Data;


namespace Prassi2ExpertUpTransfer
{
    public class TrasferPrassi
    {

        // records del trasfer
        private List<string> recordsTrasfer = new List<string>();

        // path percorso del trasfer
        private string path_File = null;
        public string Path_File { get { return this.path_File; } }
        
        // tabella sequenza invio
        private SequenzeInviiPrassi sequenzaInvio = null;
        public SequenzeInviiPrassi SequenzaInvio { get { return this.sequenzaInvio; } }

        // tabelle di conversione da Prassi a ExpertUp
        private ConversioneCodici convPrasExper = null;

        // tipi records del trasfer
        private RecordPrassi_1 recordPrassi_1 = null;
        private Dictionary<int, List<RecordPrassi_B1>> dictRecordPrassi_B1 = null;
        private Dictionary<int, List<RecordPrassi_U1>> dictRecordPrassi_U1 = null;
        private Dictionary<int, List<RecordPrassi_Z1>> dictRecordPrassi_Z1 = null;

        public TrasferPrassi(string path_FileTrasferPrassi)
        {

            string nomeFile = Path.GetFileName(path_FileTrasferPrassi);
            try
            {
                
                // lettuta txt in un Array
                string[] righeTrasfer = null;
                righeTrasfer = System.IO.File.ReadAllLines(path_FileTrasferPrassi);
                
                // carico tipi record e tabella conversione codici
                CaricaTrasferPrassi(righeTrasfer);

                // verifico la sequenza del TRASFER

                // Verifico la sequenza invio. istanzio la classe SequenzeInviiPrassi
                string sistemaInviante = recordPrassi_1.SistemaInviante().Trim();
                string ditta = recordPrassi_1.Ditta().Trim();
                this.sequenzaInvio = new SequenzeInviiPrassi(sistemaInviante, ditta);
                VerificaSequenzaInvioTrasferPrassi(sequenzaInvio);

                path_File = path_FileTrasferPrassi;

            }
            catch (Exception err)
            {
                // TODO Exception CaricaTrasferException
                throw new Eccezioni.CaricaTrasferException(nomeFile, err);
            }

        }


        #region Metodi utilizzabili dai client

        public List<RecordExpertUp_073> CreaRecords_073(int nrReg)
        {
            List<RecordExpertUp_073> records_073 = new List<RecordExpertUp_073>();

            // recupero un list con tutti i records Z1 della registrazione
            List<RecordPrassi_Z1> list_Z1 = new List<RecordPrassi_Z1>();
            bool trovato = dictRecordPrassi_Z1.TryGetValue(nrReg, out list_Z1);
            if (!trovato)
            {
                // TODO Exception RigaZ1NonTrovataException
                throw new Eccezioni.RigaZ1NonTrovataException(nrReg.ToString());
            }

            // Ciclo su tutti i records Z1 della registrazione creando per ciascuno
            // il rispettivo tipo record ExpertUp 073;
            foreach (RecordPrassi_Z1 record_Z1 in list_Z1)
            {

                RecordExpertUp_073 tr073 = new RecordExpertUp_073();

                // verifica se conto cliente o fornitore
                string partitaIva = record_Z1.PartitaIVA();
                string codFiscale = record_Z1.CodFiscale();

                // Mastro; Conto; SottoConto
                string GrCoStCnPrassiStr = record_Z1.SottoContoPdC();

                try
                {
                    string GrCoPrassiStr = null;
                    string MaCoExUpStr = null;
                    string MaCoStCnExpUpStr = null;
                    // se presente cod fiscale e/o partita iva è un conto cliente/fornitore quindi
                    // occorre convertire il gruppo e conto e poi trovare il codice sottoconto appropiato
                    if ((partitaIva != null && partitaIva.Length > 0) 
                        || 
                        (codFiscale != null && codFiscale.Length > 0))
                    {
                        // converti Gruppo&Conto(Prassi) in Mastro&Conto(ExpertUp)
                        GrCoPrassiStr = GrCoStCnPrassiStr.Substring(0, 4);
                        MaCoExUpStr = this.convPrasExper.CodiceExpertUp("Conto", GrCoPrassiStr);
                        tr073.Tr073_Mastro = Int32.Parse(MaCoExUpStr.Substring(0, 3));
                        tr073.Tr073_Conto = Int32.Parse(MaCoExUpStr.Substring(3, 2));
                        // trovo il sottoconto cliente/fornitore appropiato
                        int codAnagrafico = ConnettiExpUpDB.Instanza.getCodCliente(
                            CodiceDitta(), partitaIva, codFiscale);
                        tr073.Tr073_SottoConto = codAnagrafico;

                    }
                    else // se NON presente cod fiscale e/o partita iva è un conto standard che converto dalla tabella
                    {
                        MaCoStCnExpUpStr = this.convPrasExper.CodiceExpertUp("SottoConto", GrCoStCnPrassiStr);
                        tr073.Tr073_Mastro = Int32.Parse(MaCoStCnExpUpStr.Substring(0, 3));
                        tr073.Tr073_Conto = Int32.Parse(MaCoStCnExpUpStr.Substring(3, 2));
                        tr073.Tr073_SottoConto = Int32.Parse(MaCoStCnExpUpStr.Substring(5, 5));
                    } 
                }
                catch (FormatException err)
                {
                    // TODO Exception MastroContoSottoContoException
                    throw new Eccezioni.MastroContoSottoContoException(GrCoStCnPrassiStr, err);
                }
                
                // Descrizione della contropartita
                tr073.Tr073_DescrContr = record_Z1.Descrizione();
                // Importo contropartita
                tr073.Tr073_Importo = record_Z1.Importo_Dbl();
                // Dare o Avere ("D"=Dare, "A"=Avere)
                tr073.Tr073_DareAvere = record_Z1.DareAvere();

                records_073.Add(tr073);
                
            }


            return records_073;
        }

        public List<RecordExpertUp_076> CreaRecords_076(int nrReg)
        {
            List<RecordExpertUp_076> records_076 = new List<RecordExpertUp_076>();

            // recupero un list con tutti i records U1 della registrazione
            List<RecordPrassi_U1> list_U1 = new List<RecordPrassi_U1>();
            bool trovato = dictRecordPrassi_U1.TryGetValue(nrReg, out list_U1);
            if (!trovato)
            {
                // TODO Exception RigaU1NonTrovataException
                throw new Eccezioni.RigaU1NonTrovataException(nrReg.ToString());
            }
            else
            {
                // Ciclo su tutti i records U1 della registrazione creando per ciascuno
                // il rispettivo tipo record ExpertUp 076;
                foreach (RecordPrassi_U1 record_U1 in list_U1)
                {

                    RecordExpertUp_076 tr076 = new RecordExpertUp_076();

                    // codice IVA
                    tr076.Tr076_CodIVA = this.convPrasExper.CodiceExpertUp("CodiceIVA", record_U1.CodiceIVA());
                    // Importo imponibile
                    tr076.Tr076_Imponibile = record_U1.Imponibile_Dbl();
                    // Imposta
                    tr076.Tr076_Imposta = record_U1.Imposta_Dbl();


                    records_076.Add(tr076);
                }
            }


            return records_076;
        }

        public List<RecordExpertUp_079> CreaRecords_079(int nrReg)
        {
            List<RecordExpertUp_079> records_079 = new List<RecordExpertUp_079>();

            // recupero un list con tutti i records U1 della registrazione
            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            if (trovato)
            {
                // Ciclo su tutti i records B1 della registrazione creando per ciascuno
                // il rispettivo tipo record ExpertUp 079;
                foreach (RecordPrassi_B1 record_B1 in list_B1)
                {

                    RecordExpertUp_079 tr079 = new RecordExpertUp_079();

                    tr079.Tr079_AnnoPartita = record_B1.annoRiferimento_Int();
                    tr079.Tr079_Partita = record_B1.NrRiferimento();
                    tr079.Tr079_CodPagam = this.convPrasExper.CodiceExpertUp("CodicePagamento", record_B1.CodicePagamento());
                    tr079.Tr079_DataScad = record_B1.DataScadenza();

                    // Rel. 02.01 - scarico il totale documento sull'unica rata
                    //tr079.Tr079_Importo = record_B1.ImportoRata_Dbl();
                    tr079.Tr079_Importo = ImportoTotaleDoc(nrReg);
                    
                    tr079.Tr079_CodAgente = record_B1.CodiceAgente_Int();

                    records_079.Add(tr079);

                    // Rel. 02.01 - uscita forzata per generare solo una riga 79 (scadenze)
                    break;
                }
            }


            return records_079;
        }

        public bool Is_U1(int nrReg)
        {
            // recupero un list con tutti i records U1 della registrazione
            List<RecordPrassi_U1> list_U1 = new List<RecordPrassi_U1>();
            bool trovato = dictRecordPrassi_U1.TryGetValue(nrReg, out list_U1);
            return trovato;
        }

        public bool Is_B1(int nrReg)
        {
            // recupero un list con tutti i records B1 della registrazione
            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            return trovato;
        }

        public DateTime DataRegistrazione(int nrReg)
        {
            DateTime dataRegistrazione = new DateTime();

            List<RecordPrassi_Z1> list_Z1 = new List<RecordPrassi_Z1>();
            bool trovato = dictRecordPrassi_Z1.TryGetValue(nrReg, out list_Z1);
            if (trovato)
            {
                dataRegistrazione = list_Z1[0].DataRegistrazione();
            }
            else
            {
                // TODO Exception RigaZ1NonTrovataException
                throw new Eccezioni.RigaZ1NonTrovataException(nrReg.ToString());
            }

            return dataRegistrazione;
        }

        public DateTime DataDocumento(int nrReg)
        {
            DateTime dataDocumento = new DateTime();

            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            if (trovato)
            {
                dataDocumento = list_B1[0].DataDocumento();
            }

            return dataDocumento;
        }

        public DateTime DataTrasferimento()
        {
            return recordPrassi_1.DataTrasferimento();
        }

        public int CodiceDitta() 
        {
            int codiceDitta = 0;
            
            string codiceDittaStr = this.convPrasExper.CodiceExpertUp("CodiceDitta", recordPrassi_1.Ditta());

            try
            {
                codiceDitta = Int32.Parse(codiceDittaStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaU1ImponibileNonNumericoException
                throw new Eccezioni.CodiceDittaNonNumericoException(codiceDittaStr, err);
            }

            return codiceDitta;
        }

        public string NrDocumento(int nrReg)
        {
            string nrDocumento = null;

            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            if (trovato)
            {
                nrDocumento = list_B1[0].NrDocumento();
            }

            return nrDocumento;
        }

        public int NrProtocolloIVA(int nrReg)
        {
            int nrProtocolloIVA = 0;

            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            if (trovato)
            {
                string nrProtocolloIVAStr = list_B1[0].NrProtocolloIVA();
                try
                {
                    nrProtocolloIVA = Int32.Parse(nrProtocolloIVAStr);
                }
                catch (FormatException err)
                {
                    // TODO Exception ProtocolloIvaNonNumericoException
                    throw new Eccezioni.ProtocolloIvaNonNumericoException(nrProtocolloIVAStr, err);
                }
            }

            return nrProtocolloIVA;
        }

        public string AnnoRiferimentoCoGe(int nrReg)
        {
            string competenza = "C";

            List<RecordPrassi_Z1> list_Z1 = new List<RecordPrassi_Z1>();
            bool trovato = dictRecordPrassi_Z1.TryGetValue(nrReg, out list_Z1);
            if (trovato)
            {
                string annoRiferimento = list_Z1[0].AnnoRiferimentoCoGe();

                if (annoRiferimento.CompareTo("1") == 0) { competenza = "P"; }
            }
            else
            {
                // TODO Exception RigaZ1NonTrovataException
                throw new Eccezioni.RigaZ1NonTrovataException(nrReg.ToString());
            }

            return competenza;
        }

        public string CausaleCoGe(int nrReg)
        {
            string causale = null;

            List<RecordPrassi_Z1> list_Z1 = new List<RecordPrassi_Z1>();
            bool trovato = dictRecordPrassi_Z1.TryGetValue(nrReg, out list_Z1);
            if (trovato)
            {
                causale = list_Z1[0].CausaleCoGe();

                // converti causale
                causale = this.convPrasExper.CodiceExpertUp("CausaleCoGe", causale);
            }
            else
            {
                // TODO Exception RigaZ1NonTrovataException
                throw new Eccezioni.RigaZ1NonTrovataException(nrReg.ToString());
            }

            return causale;
        }

        public int MastroCliFor(int nrReg)
        {
            int mastroCliFor = 0;

            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            if (trovato)
            {
                string gruppoContoCliFor = list_B1[0].GruppoContoCliFor();
                // converti Gruppo&Conto(Prassi) in Mastro&Capoconto&Conto(ExpertUp)
                string contoCliForStr = this.convPrasExper.CodiceExpertUp("Conto", gruppoContoCliFor);
                try
                {
                    mastroCliFor = Int32.Parse(contoCliForStr.Substring(0, 3));
                }
                catch (FormatException err)
                {
                    // TODO Exception RigaB1GruConCliForNonNumericoException
                    throw new Eccezioni.RigaB1GruConCliForNonNumericoException(contoCliForStr, err);
                }
            }

            return mastroCliFor;
        }

        public int ContoCliFor(int nrReg)
        {
            int contoCliFor = 0;

            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            if (trovato)
            {
                string gruppoContoCliFor = list_B1[0].GruppoContoCliFor();
                // converti Gruppo&Conto(Prassi) in Mastro&Capoconto&Conto(ExpertUp)
                string contoCliForStr = this.convPrasExper.CodiceExpertUp("Conto", gruppoContoCliFor);
                try
                {
                    if (contoCliForStr.Length == 4) // è ritornato lo stesso codice Prassi...
                                                    // ...recupero il conto dal 3° e 4° carattere
                    {
                        contoCliFor = Int32.Parse(contoCliForStr.Substring(2, 2));
                    }
                    else
                    {   // recupero il conto dal 4° e 5° carattere del codice ExpertUp
                        contoCliFor = Int32.Parse(contoCliForStr.Substring(3, 2));
                    }

                    
                }
                catch (FormatException err)
                {
                    // TODO Exception RigaB1ContoCliForNonNumericoException
                    throw new Eccezioni.RigaB1ContoCliForNonNumericoException(contoCliForStr, err);
                }
            }

            return contoCliFor;
        }

        public int CodiceCliFor(int nrReg)
        {
            int codiceCliFor = 0;

            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovato = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);
            if (trovato)
            {
                
                string tipoAnagrCliFor = list_B1[0].TipoAnagrafica();
                string codiceCliForStr = list_B1[0].CodiceCliFor();

                int codAnagrafico = ConnettiExpUpDB.Instanza.getCodCliente(
                            CodiceDitta(),
                            list_B1[0].PartitaIVA(),
                            list_B1[0].CodFiscale());

                if (codAnagrafico > 0) return codAnagrafico;

                

                if (tipoAnagrCliFor.CompareTo("1") == 0)
                {
                    // converti Cliente(Prassi) in Cliente(ExpertUp)
                    codiceCliForStr = this.convPrasExper.CodiceExpertUp("Cliente", codiceCliForStr);
                }
                else
                {
                    // converti Fornitore(Prassi) in Fornitore(ExpertUp)
                    codiceCliForStr = this.convPrasExper.CodiceExpertUp("Fornitore", codiceCliForStr);
                }


                try
                {
                    codiceCliFor = Int32.Parse(codiceCliForStr);
                }
                catch (FormatException err)
                {
                    // TODO Exception RigaB1CodiceCliForNonNumericoException
                    throw new Eccezioni.RigaB1CodiceCliForNonNumericoException(codiceCliForStr, err);
                }
            }

            return codiceCliFor;
        }

        public double ImportoTotaleDoc(int nrReg)
        {
            double importo = 0;
            string importoStr = null;

            List<RecordPrassi_B1> list_B1 = new List<RecordPrassi_B1>();
            bool trovatoB1 = dictRecordPrassi_B1.TryGetValue(nrReg, out list_B1);

            List<RecordPrassi_Z1> list_Z1 = new List<RecordPrassi_Z1>();
            bool trovatoZ1 = dictRecordPrassi_Z1.TryGetValue(nrReg, out list_Z1);

            if (trovatoB1) 
            { 
                importoStr = list_B1[0].ImportoTotDoc(); 

            } 
            else if (trovatoZ1) 
            { 
                importoStr = list_Z1[0].Importo(); 
            }
            else
            {
                // TODO Exception RigaZ1NonTrovataException
                throw new Eccezioni.RigaZ1NonTrovataException(nrReg.ToString());
            }


            // conversione da string a double
            try
            {
                importo = Int32.Parse(importoStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaZ1ImportoNonNumericoException
                throw new Eccezioni.RigaZ1ImportoNonNumericoException(importoStr, err);
            }



            return importo;
        }

        // restituisce il nome del TRASFER Prassi
        public string Name_File()
        { 
            return Path.GetFileName(this.path_File);  
        }

        // restituisce tutti i numeri registrazione del trasfer
        public List<int> TuttiNrReg()
        {
            
            List<int> nrReg = new List<int>();

            foreach (KeyValuePair<int, List<RecordPrassi_Z1>> kiave in this.dictRecordPrassi_Z1)
            {
                nrReg.Add(kiave.Key);
            }

            return nrReg;

        }

        // stampa dei dati 
        public void stampaDati()
        {
            foreach (string element in recordsTrasfer)
            {
                System.Console.WriteLine(element);
            }

        }
        #endregion


        #region Metodi di elaborazione e caricamento dei Trasfer

        public bool Elabora()
        {
            bool esito = false;

            try
            {

                // Verifica tipo record " 1" e sposta in cartella di competenza con nome e nr sequenza.
                string sistemaInviante = recordPrassi_1.SistemaInviante().Trim();
                string ditta = recordPrassi_1.Ditta().Trim();
                string dataLimite = recordPrassi_1.DataLimite().Trim();
                string nrTrasferimento = recordPrassi_1.NrTrasferimento().Trim();
                string destinationFile = null;

                // INIZIO <<<<<<<<<<<<<<<<   CODICE INIBITO   >>>>>>>>>>>>>>>>>>>
                // Creo la struttura che ospita i files di trasferimento
                bool falso = false;
                if (falso)
                {

                    // ... sottocartella FilesTrasfer
                    StringBuilder path = new StringBuilder(Path.GetDirectoryName(@Path_File) + @"\FilesTrasfer");
                    // .... creo se NON esiste.
                    if (!Directory.Exists(path.ToString())) { DirectoryInfo di = Directory.CreateDirectory(path.ToString()); }

                    // ... sottocartella sistema inviante
                    path.Append(@"\" + sistemaInviante);
                    // .... creo se NON esiste.
                    if (!Directory.Exists(path.ToString())) { DirectoryInfo di = Directory.CreateDirectory(path.ToString()); }

                    // ... sottocartella codice ditta
                    path.Append(@"\" + ditta);
                    // .... creo se NON esiste.
                    if (!Directory.Exists(path.ToString())) { DirectoryInfo di = Directory.CreateDirectory(path.ToString()); }

                    StringBuilder newName = new StringBuilder("Trasfer");
                    newName.Append("_" + sistemaInviante);
                    newName.Append("_" + ditta);
                    newName.Append("_" + nrTrasferimento);
                    newName.Append("_" + dataLimite);
                    newName.Append(".txt");

                    destinationFile = path + @"\" + newName;
                    
                }
                // FINE <<<<<<<<<<<<<<<<   CODICE INIBITO   >>>>>>>>>>>>>>>>>>>

                destinationFile = Path.GetDirectoryName(@Path_File) + @"\" + Name_File();

                // INIZIO <<<<<<<<<<<<<<<<   CODICE INIBITO   >>>>>>>>>>>>>>>>>>>
                if (falso)
                {
                    // .... se già esiste lo rinomino 
                    int count = 1;
                    while (File.Exists(destinationFile))
                    {
                        File.Move(destinationFile, destinationFile + "_" + count);

                        // se non ha avuto esito il rename lancio l'eccezione
                        if (File.Exists(destinationFile))
                        {
                            // TODO Exception TrasferEsistenteException
                            throw new Eccezioni.TrasferEsistenteException(destinationFile);
                        }

                        count = count + 1;
                    }

                    // sposta il file nella nuova destinazione
                    System.IO.File.Move(Path_File, destinationFile);
                }
                // FINE <<<<<<<<<<<<<<<<   CODICE INIBITO   >>>>>>>>>>>>>>>>>>>



                this.path_File = destinationFile;


                // carico i rispettivi codici di conversione Prassi <--> ExpertUp dello StudioDitta specifico
                convPrasExper = new ConversioneCodici(recordPrassi_1.Ditta(), this.path_File);
                convPrasExper.stampaDati();

                esito = true;

            }
            catch (Exception err)
            {
                // TODO Exception TrasferGenericException
                throw new Eccezioni.TrasferGenericException(Path.GetFileName(@Path_File), err);
            }

            return esito;
        }

        
        public void CaricaTrasferPrassi(string[] righeTrasfer) 
        {
            dictRecordPrassi_B1 = new Dictionary<int, List<RecordPrassi_B1>>();
            dictRecordPrassi_U1 = new Dictionary<int, List<RecordPrassi_U1>>();
            dictRecordPrassi_Z1 = new Dictionary<int, List<RecordPrassi_Z1>>();

            // ciclo
            foreach (string riga in righeTrasfer)
            {

                // record " 1"
                if (riga.StartsWith(" 1"))
                {
                    this.recordPrassi_1 = new RecordPrassi_1(riga);
                } 
         
                // record "B1"
                if (riga.StartsWith("B1")) 
                {
                    int nrReg = Convert.ToInt32(riga.Substring(2, 6));
                    if (!this.dictRecordPrassi_B1.ContainsKey(nrReg))
                    {
                        this.dictRecordPrassi_B1.Add(nrReg, new List<RecordPrassi_B1>());
                    }
                    this.dictRecordPrassi_B1[nrReg].Add(new RecordPrassi_B1(riga));
                }

                // record "U1"
                if (riga.StartsWith("U1")) 
                {
                    int nrReg = Convert.ToInt32(riga.Substring(2, 6));
                    if (!this.dictRecordPrassi_U1.ContainsKey(nrReg))
                    {
                        this.dictRecordPrassi_U1.Add(nrReg, new List<RecordPrassi_U1>());
                    }
                    this.dictRecordPrassi_U1[nrReg].Add(new RecordPrassi_U1(riga)); 
                }

                // record "Z1"
                if (riga.StartsWith("Z1")) 
                {
                    int nrReg = Convert.ToInt32(riga.Substring(2, 6));
                    if (!this.dictRecordPrassi_Z1.ContainsKey(nrReg))
                    {
                        this.dictRecordPrassi_Z1.Add(nrReg, new List<RecordPrassi_Z1>());
                    }
                    this.dictRecordPrassi_Z1[nrReg].Add(new RecordPrassi_Z1(riga));
                }


                recordsTrasfer.Add(riga);

            }

        }


        private void VerificaSequenzaInvioTrasferPrassi(SequenzeInviiPrassi sequenzaInvio)
        {

            try
            {

                if (SequenzaInvio.NrInvio > 0)
                {
                    int nrTrasferimentoInt = Int32.Parse(recordPrassi_1.NrTrasferimento().Trim());
                    if (nrTrasferimentoInt != (SequenzaInvio.NrInvio + 1))
                    {
                        String messaggio = String.Format(" Errore nella sequenza di invio. " + 
                         "Sistema inviante = {0}; Ditta = {1}; Ultimo nr ricevuto = {2}; Attuale nr in ricezione = {3}",
                         SequenzaInvio.Sistema, SequenzaInvio.Ditta, SequenzaInvio.NrInvio, nrTrasferimentoInt);
                        // TODO Exception TrasferSequenzaInvioException
                        throw new Eccezioni.TrasferSequenzaInvioException(messaggio);
                    }
                }


            }
            catch (Exception err)
            {
                // TODO Exception rilanciata
                throw err;
            }

        }


        public void AggiornaSequenzaInvio()
        {

            try
            {
                SequenzaInvio.AggiornaSequenza(Int32.Parse(recordPrassi_1.NrTrasferimento().Trim()));
            }
            catch (Exception err)
            {
                // TODO Exception rilanciata
                throw err;
            }

        }
        

        #endregion

    }



    // Record Trasfer
    abstract class RecordTrasferPrassi
    {
        private string riga;
        private int nrReg;

        public string Riga { get { return this.riga; } set { this.riga = value; } }
        public int NrReg { get { return this.nrReg; } set { this.nrReg = value; } }

        public enum EnumTipo
        {
            R1,
            Z1,
            U1,
            B1
        }

        public abstract EnumTipo Tipo();

        public RecordTrasferPrassi(string riga) 
        {
            this.riga = riga;
        }

    }



    #region sottoclassi di RecordTrasferPrassi

    #region sottoclasse TipoRecord " 1"
    // Record " 1"
    class RecordPrassi_1 : RecordTrasferPrassi
    {
        public override EnumTipo Tipo() { return EnumTipo.R1; }

        public RecordPrassi_1(string riga)
            :base(riga)
        {

        }


        public string SistemaInviante()
        {
            return Riga.Substring(15, 10);
        }

        public string Ditta()
        {
            return Riga.Substring(25, 4);
        }

        public string NrTrasferimento()
        {
            return Riga.Substring(29, 3);
        }

        public string DataLimite()
        {
            return Riga.Substring(32, 6);
        }

        public DateTime DataTrasferimento()
        {
            string dateString = Riga.Substring(32, 6);
            string format = "yyMMdd";
            CultureInfo provider = new CultureInfo("it-IT");
            DateTime dateValue = new DateTime();

            try
            {
                dateValue = DateTime.ParseExact(dateString, format, provider);
            }
            catch (FormatException err)
            {
                // TODO Exception Riga_1DataErrataException
                throw new Eccezioni.Riga_1DataErrataException(dateString, err);
            }

            return dateValue;
        }


    }
    #endregion

    #region sottoclasse TipoRecord "B1"
    // Record "B1"
    class RecordPrassi_B1 : RecordTrasferPrassi
    {
        public override EnumTipo Tipo() { return EnumTipo.B1; }

        public RecordPrassi_B1(string riga)
            : base(riga)
        {
        }


        public DateTime DataDocumento()
        {

            string dateString = Riga.Substring(44, 6);
            string format = "yyMMdd";
            CultureInfo provider = new CultureInfo("it-IT");
            DateTime dateValue = new DateTime();

            try
            {
                dateValue = DateTime.ParseExact(dateString, format, provider);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaB1DataErrataException
                throw new Eccezioni.RigaB1DataErrataException("Data documento", dateString, err);
            }

            return dateValue;
        }

        public DateTime DataScadenza()
        {

            string dateString = Riga.Substring(140, 6);
            string format = "yyMMdd";
            CultureInfo provider = new CultureInfo("it-IT");
            DateTime dateValue = new DateTime();

            try
            {
                dateValue = DateTime.ParseExact(dateString, format, provider);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaB1DataErrataException
                throw new Eccezioni.RigaB1DataErrataException("Data scadenza", dateString, err);
            }

            return dateValue;
        }

        public double ImportoRata_Dbl()
        {
            double importo = 0;
            string importoStr = Riga.Substring(116, 11); ;

            // conversione da string a double
            try
            {
                importo = Double.Parse(importoStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaB1ImportoNonNumericoException
                throw new Eccezioni.RigaB1ImportoNonNumericoException(importoStr, err);
            }

            return importo;
        }

        public int annoRiferimento_Int()
        {
            int anno = 0;
            string annoStr = Riga.Substring(26, 2);

            // conversione da string a int
            try
            {
                anno = 2000 + Int32.Parse(annoStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaB1DataErrataException
                throw new Eccezioni.RigaB1DataErrataException("Anno riferimento", annoStr, err);
            }

            return anno;
        }

        public string NrRiferimento()
        {
            return Riga.Substring(28, 7);
        }

        public string NrDocumento()
        {
            return Riga.Substring(50, 7);
        }

        public string NrProtocolloIVA()
        {
            return Riga.Substring(58, 5);
        }

        public string GruppoContoCliFor()
        {
            return Riga.Substring(168, 4);
        }
        
        public string TipoAnagrafica()
        {
            return Riga.Substring(15, 1);
        }

        public string CodiceCliFor()
        {
            return Riga.Substring(20, 6);
        }

        public string CodicePagamento()
        {
            return Riga.Substring(112, 2);
        }

        public int CodiceAgente_Int()
        {

            int codAgente = 0;
            string codAgenteStr = Riga.Substring(172, 6); ;

            // conversione da string a int
            try
            {
                codAgente = Int32.Parse(codAgenteStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaB1CodiceAgenteNonNumericoException
                throw new Eccezioni.RigaB1CodiceAgenteNonNumericoException(codAgenteStr, err);
            }

            return codAgente;
        }

        public string ImportoTotDoc()
        {
            return Riga.Substring(68, 11);
        }

        public string PartitaIVA()
        {
            return Riga.Substring(239, 11);
        }

        public string CodFiscale()
        {
            return Riga.Substring(223, 16);
        }


    }
    #endregion

    #region sottoclasse TipoRecord "U1"
    // Record "U1"
    class RecordPrassi_U1 : RecordTrasferPrassi
    {
        public override EnumTipo Tipo() { return EnumTipo.U1; }

        public RecordPrassi_U1 (string riga)
            : base(riga)
        {
        }

        public string CodiceIVA()
        {
            return Riga.Substring(32, 2);
        }

        public double Imponibile_Dbl()
        {
            double imponibile = 0;
            string imponibileStr = Riga.Substring(21, 11); ;

            // conversione da string a double
            try
            {
                imponibile = Int32.Parse(imponibileStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaU1ImportoNonNumericoException
                throw new Eccezioni.RigaU1ImportoNonNumericoException("Imponibile", imponibileStr, err);
            }

            return imponibile;
        }

        public double Imposta_Dbl()
        {
            double imposta = 0;
            string impostaStr = Riga.Substring(34, 9); ;

            // conversione da string a double
            try
            {
                imposta = Int32.Parse(impostaStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaU1ImportoNonNumericoException
                throw new Eccezioni.RigaU1ImportoNonNumericoException("Imposta", impostaStr, err);
            }

            return imposta;
        }

        public string PartitaIVA()
        {
            return Riga.Substring(239, 11);
        }

        public string CodFiscale()
        {
            return Riga.Substring(223, 16);
        }

    }
    #endregion

    #region sottoclasse TipoRecord "Z1"
    // Record "Z1"
    class RecordPrassi_Z1 : RecordTrasferPrassi
    {
       public override EnumTipo Tipo() { return EnumTipo.Z1; }

        public RecordPrassi_Z1 (string riga)
            : base(riga)
        {
        }

        public DateTime DataRegistrazione()
        {

            string dateString = Riga.Substring(15, 6);
            string format = "yyMMdd";
            CultureInfo provider = new CultureInfo("it-IT");
            DateTime dateValue = new DateTime();

            try
            {
                dateValue = DateTime.ParseExact(dateString, format, provider);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaZ1DataErrataException
                throw new Eccezioni.RigaZ1DataErrataException(dateString, err);
            }

            return dateValue;
        }

        public string AnnoRiferimentoCoGe()
        {
            return Riga.Substring(21, 1);
        }

        public string CausaleCoGe()
        {
            return Riga.Substring(41, 3);
        }

        public string Importo()
        {
            return Riga.Substring(97, 11);
        }

        public double Importo_Dbl()
        {
            double importo = 0;
            string importoStr = Riga.Substring(97, 11); ;
            
            // conversione da string a double
            try
            {
                importo = Int32.Parse(importoStr);
            }
            catch (FormatException err)
            {
                // TODO Exception RigaZ1ImportoNonNumericoException
                throw new Eccezioni.RigaZ1ImportoNonNumericoException(importoStr, err);
            }

            return importo;
        }

        public string GruppoPdC()
        {
            return Riga.Substring(74, 2);
        }

        public string ContoPdC()
        {
            return Riga.Substring(74, 4);
        }

        public string SottoContoPdC()
        {
            return Riga.Substring(74, 10);
        }

        public string Descrizione()
        {
            return Riga.Substring(44, 30);
        }

        public string DareAvere()
        {
            return Riga.Substring(84, 1);
        }

        public string PartitaIVA()
        {
            string partitaiva = null;

            if (Riga.Length > 249)
            {
                partitaiva = Riga.Substring(239, 11).Trim();
            }

            return partitaiva;
        }

        public string CodFiscale()
        {
            string codfiscale = null;
            if (Riga.Length > 233)
            {
                codfiscale = Riga.Substring(223, 16).Trim();
            }

            return codfiscale;
        }

    }
    #endregion
    #endregion
}